package com.greenold.order.service.impl;

import java.util.Date;
import java.util.List;

//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.greenold.common.core.domain.AjaxResult;
import com.greenold.common.exception.ServiceException;
import com.greenold.order.dto.OrderDto;
import com.greenold.order.domain.OrderDTO;
import com.greenold.refunds.service.IRefundService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import com.greenold.order.mapper.OrderMapper;
import com.greenold.order.domain.Order;
import com.greenold.order.service.IOrderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Transactional;

/**
 * 订单Service业务层处理
 *
 * @author ruoyi
 * @date 2025-10-13
 */
@Service
public class OrderServiceImpl implements IOrderService {
    //    // 声明日志对象（核心：通过 LoggerFactory 获取 Logger）
    private static final Logger log = LoggerFactory.getLogger(OrderServiceImpl.class);


    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private IRefundService irefundService;

    // 状态常量（与数据库一致）
    private static final String UNPAID_ORDER_STATUS = "0"; // 待支付   订单状态
    private static final String UNPAID_PAY_STATUS = "0";   // 待支付  交易状态
    private static final String CLOSED_PAY_STATUS = "2";    // 已关闭  交易状态
    private static final String ClOSED_ORDER_STATUS = "4";//已关闭 订单状态
    private static final String ClOSED_CANCEL_REASON = "未支付超过15分钟，自动关闭";




// ===================== 新增：简便退款码生成方法 =====================
    /**
     * 简便生成18位退款码（TKD前缀+15位毫秒时间戳，总18位）
     * 无需高并发处理，直接生成即可
     */
    @Override
    public String generateSimpleRefundCode() {
        String prefix = "TKD"; // 固定前缀（3位）
        // 生成15位后缀：用当前毫秒时间戳（转字符串后取后15位，不够补0）
        String timestamp = String.valueOf(System.currentTimeMillis());
        String suffix = String.format("%15s", timestamp).replace(' ', '0'); // 补0到15位
        if (suffix.length() > 15) {
            suffix = suffix.substring(suffix.length() - 15); // 超长则截取后15位
        }
        return prefix + suffix; // 3+15=18位
    }


    /**
     * 查询订单
     *
     * @param id 订单主键
     * @return 订单
     */
    @Override
    public Order selectOrderById(String id) {
        return orderMapper.selectOrderById(id);
    }

    /**
     * 查询订单列表
     *
     * @param order 订单
     * @return 订单
     */
    @Override
    public List<Order> selectOrderList(Order order) {
        return orderMapper.selectOrderList(order);
    }

     /**
     * 查询订单内容
     *
     * @param orderDTO 订单DTO
     * @return 订单集合
     */
    @Override
    public List<OrderDTO> selectOrderInfo(OrderDTO orderDTO) {
        return orderMapper.selectOrderInfo(orderDTO);
    }

    /**
     * 新增订单
     *
     * @param order 订单
     * @return 结果
     */
    @Override
    public int insertOrder(Order order) {
        return orderMapper.insertOrder(order);
    }

    /**
     * 修改订单
     *
     * @param order 订单
     * @return 结果
     */
    @Override
    public int updateOrder(Order order) {
        return orderMapper.updateOrder(order);
    }

    /**
     * 批量删除订单
     *
     * @param ids 需要删除的订单主键
     * @return 结果
     */
//    @Override
//    public int deleteOrderByIds(String[] ids)
//    {
//        return orderMapper.deleteOrderByIds(ids);
//    }

    /**
     *
     */

    @Override
    public int cancelOrder(String id, String cancelReason) {


        // 1. 查询订单（可自定义查询方法，或用 MyBatis 的 selectOne）
        Order order = orderMapper.selectOrderById(id); // 若没baseMapper，可自定义selectById方法
        if (order == null) {
            throw new ServiceException("订单不存在");
        }

        // 2. 校验状态（仅待支付可取消）
        if (!"0".equals(order.getOrderStatus()) || !"0".equals(order.getPayStatus())) {
            throw new ServiceException("仅待支付订单可取消");
        }

        // 3. 调用自定义的更新方法（无需 baseMapper）
        return orderMapper.updateOrderStatus(
                id,
                "4", // 新订单状态：已关闭
                "2", // 新交易状态：已关闭
                cancelReason
        );
    }

    /**
     * 定时任务：每分钟检查并关闭超过15分钟的未支付订单
     * cron表达式：每分钟第0秒执行
     */

//    @Transactional(rollbackFor = Exception.class) 是 Spring 框架中用于声明式事务管理的核心注解，
//    作用是控制方法内的数据库操作具有 “事务性”，且遇到所有 Exception 及其子类异常时，强制触发事务回滚。
//    假设 “取消订单” 需要同时执行两步：
//    数据库更新订单状态为 “已取消”；
//    向消息队列发送 “订单取消通知”。
//    若中途发送消息失败（抛出 MQException，属于受检异常），默认情况下事务不会回滚（订单状态已更新，但消息未发，数据不一致）。
//    此时，用 @Transactional(rollbackFor = Exception.class) 修饰 “取消订单” 方法，当 MQException 抛出时，事务会回滚，订单状态会被恢复为 “未取消”，保证数据一致。
    @Scheduled(cron = "0 0/1 * * * ?")
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void autoCloseExpiredOrders() {
        // 1. 查询符合条件的订单
        List<Order> expiredOrders = orderMapper.selectUnpaidOrdersOver15Min(
                UNPAID_ORDER_STATUS,
                UNPAID_PAY_STATUS
        );

        if (expiredOrders.isEmpty()) {
            log.info("无超过15分钟的未支付订单，无需处理");
            return;
        }

        // 2. 批量更新为“已过期”状态
        Date now = new Date();
        for (Order order : expiredOrders) {
            order.setOrderStatus(ClOSED_ORDER_STATUS);
            order.setPayStatus(CLOSED_PAY_STATUS);
            order.setCancelReason(ClOSED_CANCEL_REASON);
            order.setUpdateTime(now);
            // 适配现有方法：提取属性，传递4个参数
            orderMapper.updateOrderStatus(
                    order.getId(),                  // id
                    order.getOrderStatus(), // orderStatus
                    order.getPayStatus(),    // payStatus
                    order.getCancelReason()         // cancelReason
            );
        }

        log.info("自动关闭" + expiredOrders.size() + "笔过期订单");
    }











    /**
     * 补充：退款后更新订单状态（退款中）
     * @param orderId 订单ID
     */
    @Override
    public void updateOrderForRefund(String orderId) {
        Order order = selectOrderById(orderId);
        if (order == null) {
            throw new ServiceException("订单不存在，无法更新退款状态");
        }

        if("1".equals(order.getOrderStatus())) {
            // 更新订单状态：订单状态=5（已退款）、交易状态=4（退款成功）、是否有退款=1
            orderMapper.updateOrderStatus(
                    orderId,
                    "5", // 订单状态：已退款（对应Order实体的枚举）
                    "4", // 交易状态：退款成功（对应Order实体的枚举）
                    "退款申请已提交" // 可把退款码加入原因，方便查看 // 取消原因补充
            );
        }
        if("2".equals(order.getOrderStatus())){
            orderMapper.updateOrderStatus(
                    orderId,
                    "2",
                    "4",
                    "退款申请已提交"
            );
        }
        // 补充：更新“是否有退款”为1（避免重复退款）
        Order updateOrder = new Order();
        updateOrder.setId(orderId);

        updateOrder.setHasRefund(1); // 0=无退款，1=有退款
        orderMapper.updateOrder(updateOrder);
    }
    /*
     * 获取若以前端订单列表包含老人姓名，客户姓名
     * */
    @Override
    public  List<OrderDto> listAll(Order order){
        List<OrderDto> orders = orderMapper.selectOrderListAddElerNameAndCustomerName(order);
        return orders;
    }
    @Override
    public AjaxResult deleteOrderById(String id){
        int i = orderMapper.deleteOrderById(id);
        if(i>0){
            return AjaxResult.success("删除成功！");
        }

        return AjaxResult.success("删除失败！");

    }
    @Override
    public  AjaxResult QueryOrderId(String bizOrderNo){
        Long l = orderMapper.selectOrderIdBybizOrderNo(bizOrderNo);
        String orderId = l.toString();
        return AjaxResult.success(orderId);
    }

    @Override
    public OrderDto selectOrderDtoById(String id) {
        // 实现代码（根据之前补充）
        Order orderQuery = new Order();
        orderQuery.setId(id);
        List<OrderDto> orderDtos = orderMapper.selectOrderListAddElerNameAndCustomerName(orderQuery);
        return orderDtos.isEmpty() ? null : orderDtos.get(0);
    }

}